package com.xiaoba.shoppingcart.service.impl;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.alibaba.fastjson.JSON;
import com.xiaoba.common.core.domain.Result;
import com.xiaoba.common.core.utils.uuid.UUID;
import com.xiaoba.common.redis.service.RedisService;
import com.xiaoba.common.security.utils.SecurityUtils;
import com.xiaoba.product.domain.SkuInfo;
import com.xiaoba.shoppingcart.domain.Cartitem;
import com.xiaoba.shoppingcart.feign.ProductFeignService;
import com.xiaoba.shoppingcart.mapper.CartitemMapper;
import com.xiaoba.system.domain.model.LoginUser;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import com.xiaoba.shoppingcart.mapper.CartMapper;
import com.xiaoba.shoppingcart.domain.Cart;
import com.xiaoba.shoppingcart.service.ICartService;
import org.springframework.web.bind.annotation.GetMapping;

/**
 * 购物车Service业务层处理
 *
 * @author gd
 * @date 2024-06-07
 */
@Service
public class CartServiceImpl implements ICartService
{
    @Autowired
    private CartMapper cartMapper;

    @Autowired
    private CartitemMapper cartitemMapper;

    @Autowired
    private RedisService redisService;

    @Autowired
    private RedisTemplate<String,String> redisTemplate;

    @Autowired
    private ProductFeignService productFeignService;


    /**
     * 查询购物车
     *
     * @param shoppingcartId 购物车主键
     * @return 购物车
     */
    @Override
    public Cart selectCartByShoppingcartId(Long shoppingcartId)
    {
        return cartMapper.selectCartByShoppingcartId(shoppingcartId);
    }

    /**
     * 查询购物车列表
     *
     * @param cart 购物车
     * @return 购物车
     */
    @Override
    public List<Cart> selectCartList(Cart cart)
    {
        return cartMapper.selectCartList(cart);
    }

    /**
     * 新增购物车
     *
     * @param cart 购物车
     * @return 结果
     */
    @Override
    public int insertCart(Cart cart)
    {
            return cartMapper.insertCart(cart);
    }

    /**
     * 修改购物车
     *
     * @param cart 购物车
     * @return 结果
     */
    @Override
    public int updateCart(Cart cart)
    {
        return cartMapper.updateCart(cart);
    }

    /**
     * 批量删除购物车
     *
     * @param shoppingcartIds 需要删除的购物车主键
     * @return 结果
     */
    @Override
    public int deleteCartByShoppingcartIds(Long[] shoppingcartIds)
    {
        return cartMapper.deleteCartByShoppingcartIds(shoppingcartIds);
    }

    /**
     * 删除购物车信息
     *
     * @param shoppingcartId 购物车主键
     * @return 结果
     */
    @Override
    public int deleteCartByShoppingcartId(Long shoppingcartId)
    {
        return cartMapper.deleteCartByShoppingcartId(shoppingcartId);
    }



    /**
     * 根据用户id检查有没有购物车对象
     * 1.1.1 如果有返回购物车对象
     *  1.1.2 如果没有 添加购物车表   skuId  count
     *      1.1.2.1 添加完购物车表获取 购物车表id
     * 1.2 根据购物车id添加购物明细
     *  1.2.1 判断购物车明细有没有  skuId cardId
     *  1.2.2 如果有    数量+count
     *  1.2.3 如果没有 新增
     */
    @Override
    public void addCart(Long skuId, Integer num){
        // 获取当前的用户
        LoginUser loginUser = SecurityUtils.getLoginUser();
        if(loginUser == null){
            //抛出异常
            throw new RuntimeException("必须登录");
        }
        // 从缓存取出数据
        Map<String, Object> cacheMap = redisService.getCacheMap(loginUser.getUserid().toString());
        // 拿到购物车  遍历购物车
            if(cacheMap.values().size() > 0){// 如果没有 添加购物车表

                Map<String, Cartitem> updatedCacheMap = new HashMap<>();

                for (Object value : cacheMap.values()) {
                    if (value instanceof Cart) {
                        Cart cart = (Cart) value;
                        String shoppingcartId = cart.getShoppingcartId();
                        Cartitem cartitem = cartitemMapper.selectCartItemBySkuIdAndShoppingcartId(skuId, shoppingcartId);

                        if (cartitem != null) {
                            // 如果购物车已经有该商品，更新数量和总价
                            cartitem.setDetailCount(cartitem.getDetailCount() + num);
                            cartitem.setDetailTotalmoney(cartitem.getDetailTotalmoney().add(cartitem.getDetailSkuPrice().multiply(new BigDecimal(num))));
                            cartitemMapper.updateCartItemInfo(cartitem);
                        } else {
                            // 如果购物车没有该商品，创建新的购物车商品明细
                            cartitem = createCartValueInfo(skuId, num, shoppingcartId);
                            cartitemMapper.insertCartitem(cartitem);
                        }
                        // 更新缓存数据
                        updatedCacheMap.put(cartitem.getDetailId().toString(), cartitem);
                    }
                }
            }else {
                // 根据用户id查询 数据库是否有购物车
                Cart cart = cartMapper.selectCartByuserid(loginUser.getUserid());

                if (cart != null) {
                    // 将购物车信息存入redis
                    String userId = String.valueOf(loginUser.getUserid());
                    cacheCartInfo(userId, cart);

                    Cartitem cartValueInfo = createAndInsertCartItem(String.valueOf(skuId), num, cart.getShoppingcartId());
                    // 将购物车明细存入redis
                    cacheCartItemInfo(cartValueInfo.getDetailId().toString(), cartValueInfo);
                } else {
                    // 如果没有购物车，创建新购物车
                    Cart cart1 = new Cart();
                    cart1.setShoppingcartUserId(loginUser.getUserid());
                    String cartId = UUID.randomUUID().toString();
                    cart1.setShoppingcartId(cartId);

                    // 将新的购物车信息存入redis
                    String userId = String.valueOf(loginUser.getUserid());
                    cacheCartInfo(userId, cart1);

                    // 根据用户id查询数据库是否有购物车
                    Cart cartList = cartMapper.selectCartByuserid(loginUser.getUserid());
                    if (cartList != null) {
                        Cartitem cartitem = createAndInsertCartItem(String.valueOf(skuId), num, cartId);
                        // 将购物车明细存入redis
                        cacheCartItemInfo(cartitem.getDetailCartid().toString(), cartitem);
                    }
                }
            }
    }



    /**
     * 将购物车信息存入Redis
     */
    private void cacheCartInfo(String userId, Cart cart) {
        Map<String, Cart> cartMap = new HashMap<>();
        cartMap.put(userId, cart);
        redisService.setCacheMap(userId, cartMap);
    }

    /**
     * 将购物车明细存入Redis
     */
    private void cacheCartItemInfo(String detailId, Cartitem cartItem) {
        HashMap<String, Cartitem> cartitemHashMap = new HashMap<>();
        cartitemHashMap.put(detailId, cartItem);
        redisService.setCacheMap(detailId, cartitemHashMap);
    }

    /**
     * 创建并插入购物车明细
     */
    private Cartitem createAndInsertCartItem(String skuId, int num, String cartId) {
        Cartitem cartValueInfo = createCartValueInfo(Long.valueOf(skuId), num, cartId);
        cartitemMapper.insertCartitem(cartValueInfo);
        return cartValueInfo;
    }

    /**
     * 创建购物车明细
     * @param skuId 商品ID
     * @param num  数量
     * @param shoppingcartId  商店ID
     */
    private Cartitem createCartValueInfo(Long skuId, Integer num, String shoppingcartId) {
        // 创建购物车明细表
        Cartitem cartitem = new Cartitem();
        // 根据skuId查询sku信息  远程调用
        Result<SkuInfo> skuInfoResult = productFeignService.listByskuId(skuId);
        SkuInfo skuInfo = skuInfoResult.getData();
        // 设置购物车商品明细信息
        cartitem.setDetailSkuId(skuId);
        cartitem.setDetailSkuImages(skuInfo.getSkuImg());
        cartitem.setDetailSkuTitle(skuInfo.getSkuTitle());
        cartitem.setDetailSaleAttrs(skuInfo.getAttrValue());
        cartitem.setDetailSkuPrice(skuInfo.getSkuPrice());
        cartitem.setDetailCount(Long.valueOf(num));
        cartitem.setDetailChecked(1L);
        cartitem.setDetailTotalmoney(skuInfo.getSkuPrice().multiply(new BigDecimal(num)));
        cartitem.setDetailCartid(shoppingcartId);
        // 返回数据
        return cartitem;
    }

    @Override
    public Result updateStatusToCart(Long shoppingcartId) {
        return cartMapper.updateStatusToCart(shoppingcartId);
    }
}

















